package antlr;

import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.CharStream;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.Lexer;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;

public class BasicRegexpLexer extends Lexer {
    public static final int EOF = -1;
    public static final int Or = 4;
    public static final int Star = 5;
    public static final int Plus = 6;
    public static final int QuestionMark = 7;
    public static final int CurlyBracketStart = 8;
    public static final int Decimal = 9;
    public static final int CurlyBracketEnd = 10;
    public static final int Comma = 11;
    public static final int Dot = 12;
    public static final int ShortCharClass = 13;
    public static final int Escape = 14;
    public static final int RoundBracketStart = 15;
    public static final int RoundBracketEnd = 16;
    public static final int Colon = 17;
    public static final int UpperAlpha = 18;
    public static final int LowerAlpha = 19;
    public static final int UnderScore = 20;
    public static final int Digit = 21;
    public static final int SquareBracketStart = 22;
    public static final int SquareBracketEnd = 23;
    public static final int And = 24;
    public static final int Hyphen = 25;
    public static final int Equals = 26;
    public static final int LessThan = 27;
    public static final int GreaterThan = 28;
    public static final int ExclamationMark = 29;
    public static final int OtherChar = 30;
    public static final int EscapeSequence = 31;
    public static final int Caret = 32;
    public static final int Dollar = 33;

    // delegates
    // delegators

    public BasicRegexpLexer() {
        ;
    }

    public BasicRegexpLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }

    public BasicRegexpLexer(CharStream input, RecognizerSharedState state) {
        super(input, state);

    }

    public String getGrammarFileName() {
        return "BasicRegexp.g";
    }

    // $ANTLR start "Decimal"
    public final void mDecimal() throws RecognitionException {
        try {
            int _type = Decimal;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:198:9: ( ( Digit )+ )
            // BasicRegexp.g:198:11: ( Digit )+
            {
                // BasicRegexp.g:198:11: ( Digit )+
                int cnt1 = 0;
                loop1:
                do {
                    int alt1 = 2;
                    int LA1_0 = input.LA(1);

                    if (((LA1_0 >= '0' && LA1_0 <= '9'))) {
                        alt1 = 1;
                    }


                    switch (alt1) {
                        case 1:
                            // BasicRegexp.g:198:11: Digit
                        {
                            mDigit();

                        }
                        break;

                        default:
                            if (cnt1 >= 1) break loop1;
                            EarlyExitException eee =
                                    new EarlyExitException(1, input);
                            throw eee;
                    }
                    cnt1++;
                } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Decimal"

    // $ANTLR start "Digit"
    public final void mDigit() throws RecognitionException {
        try {
            // BasicRegexp.g:202:9: ( '0' .. '9' )
            // BasicRegexp.g:202:11: '0' .. '9'
            {
                matchRange('0', '9');

            }

        }
        finally {
        }
    }
    // $ANTLR end "Digit"

    // $ANTLR start "EscapeSequence"
    public final void mEscapeSequence() throws RecognitionException {
        try {
            int _type = EscapeSequence;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:205:2: ( Escape ~ ( LowerAlpha | UpperAlpha | Digit ) )
            // BasicRegexp.g:205:4: Escape ~ ( LowerAlpha | UpperAlpha | Digit )
            {
                mEscape();
                if ((input.LA(1) >= '\u0000' && input.LA(1) <= '/') || (input.LA(1) >= ':' && input.LA(1) <= '@') || (input.LA(1) >= '[' && input.LA(1) <= '`') || (input.LA(1) >= '{' && input.LA(1) <= '\uFFFF')) {
                    input.consume();

                } else {
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    recover(mse);
                    throw mse;
                }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EscapeSequence"

    // $ANTLR start "LowerAlpha"
    public final void mLowerAlpha() throws RecognitionException {
        try {
            int _type = LowerAlpha;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:208:13: ( 'a' .. 'z' )
            // BasicRegexp.g:208:15: 'a' .. 'z'
            {
                matchRange('a', 'z');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LowerAlpha"

    // $ANTLR start "UpperAlpha"
    public final void mUpperAlpha() throws RecognitionException {
        try {
            int _type = UpperAlpha;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:209:13: ( 'A' .. 'Z' )
            // BasicRegexp.g:209:15: 'A' .. 'Z'
            {
                matchRange('A', 'Z');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UpperAlpha"

    // $ANTLR start "UnderScore"
    public final void mUnderScore() throws RecognitionException {
        try {
            int _type = UnderScore;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:210:13: ( '_' )
            // BasicRegexp.g:210:15: '_'
            {
                match('_');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UnderScore"

    // $ANTLR start "Plus"
    public final void mPlus() throws RecognitionException {
        try {
            int _type = Plus;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:212:8: ( '+' )
            // BasicRegexp.g:212:10: '+'
            {
                match('+');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Plus"

    // $ANTLR start "Star"
    public final void mStar() throws RecognitionException {
        try {
            int _type = Star;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:213:8: ( '*' )
            // BasicRegexp.g:213:10: '*'
            {
                match('*');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Star"

    // $ANTLR start "Or"
    public final void mOr() throws RecognitionException {
        try {
            int _type = Or;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:214:6: ( '|' )
            // BasicRegexp.g:214:8: '|'
            {
                match('|');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Or"

    // $ANTLR start "Dot"
    public final void mDot() throws RecognitionException {
        try {
            int _type = Dot;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:215:7: ( '.' )
            // BasicRegexp.g:215:9: '.'
            {
                match('.');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Dot"

    // $ANTLR start "SquareBracketStart"
    public final void mSquareBracketStart() throws RecognitionException {
        try {
            int _type = SquareBracketStart;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:216:20: ( '[' )
            // BasicRegexp.g:216:22: '['
            {
                match('[');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SquareBracketStart"

    // $ANTLR start "SquareBracketEnd"
    public final void mSquareBracketEnd() throws RecognitionException {
        try {
            int _type = SquareBracketEnd;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:217:18: ( ']' )
            // BasicRegexp.g:217:20: ']'
            {
                match(']');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SquareBracketEnd"

    // $ANTLR start "RoundBracketStart"
    public final void mRoundBracketStart() throws RecognitionException {
        try {
            int _type = RoundBracketStart;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:218:19: ( '(' )
            // BasicRegexp.g:218:21: '('
            {
                match('(');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RoundBracketStart"

    // $ANTLR start "RoundBracketEnd"
    public final void mRoundBracketEnd() throws RecognitionException {
        try {
            int _type = RoundBracketEnd;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:219:18: ( ')' )
            // BasicRegexp.g:219:20: ')'
            {
                match(')');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RoundBracketEnd"

    // $ANTLR start "CurlyBracketStart"
    public final void mCurlyBracketStart() throws RecognitionException {
        try {
            int _type = CurlyBracketStart;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:220:19: ( '{' )
            // BasicRegexp.g:220:21: '{'
            {
                match('{');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CurlyBracketStart"

    // $ANTLR start "CurlyBracketEnd"
    public final void mCurlyBracketEnd() throws RecognitionException {
        try {
            int _type = CurlyBracketEnd;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:221:18: ( '}' )
            // BasicRegexp.g:221:20: '}'
            {
                match('}');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CurlyBracketEnd"

    // $ANTLR start "Comma"
    public final void mComma() throws RecognitionException {
        try {
            int _type = Comma;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:222:9: ( ',' )
            // BasicRegexp.g:222:11: ','
            {
                match(',');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Comma"

    // $ANTLR start "Escape"
    public final void mEscape() throws RecognitionException {
        try {
            int _type = Escape;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:224:10: ( '\\\\' )
            // BasicRegexp.g:224:12: '\\\\'
            {
                match('\\');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Escape"

    // $ANTLR start "ShortCharClass"
    public final void mShortCharClass() throws RecognitionException {
        try {
            int _type = ShortCharClass;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:226:2: ( Escape ( 'd' | 'D' | 's' | 'S' | 'w' | 'W' ) )
            // BasicRegexp.g:226:4: Escape ( 'd' | 'D' | 's' | 'S' | 'w' | 'W' )
            {
                mEscape();
                if (input.LA(1) == 'D' || input.LA(1) == 'S' || input.LA(1) == 'W' || input.LA(1) == 'd' || input.LA(1) == 's' || input.LA(1) == 'w') {
                    input.consume();

                } else {
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    recover(mse);
                    throw mse;
                }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ShortCharClass"

    // $ANTLR start "And"
    public final void mAnd() throws RecognitionException {
        try {
            int _type = And;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:229:7: ( '&' )
            // BasicRegexp.g:229:9: '&'
            {
                match('&');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "And"

    // $ANTLR start "Hyphen"
    public final void mHyphen() throws RecognitionException {
        try {
            int _type = Hyphen;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:230:10: ( '-' )
            // BasicRegexp.g:230:12: '-'
            {
                match('-');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Hyphen"

    // $ANTLR start "Caret"
    public final void mCaret() throws RecognitionException {
        try {
            int _type = Caret;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:231:9: ( '^' )
            // BasicRegexp.g:231:11: '^'
            {
                match('^');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Caret"

    // $ANTLR start "Colon"
    public final void mColon() throws RecognitionException {
        try {
            int _type = Colon;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:232:9: ( ':' )
            // BasicRegexp.g:232:11: ':'
            {
                match(':');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Colon"

    // $ANTLR start "Dollar"
    public final void mDollar() throws RecognitionException {
        try {
            int _type = Dollar;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:233:10: ( '$' )
            // BasicRegexp.g:233:12: '$'
            {
                match('$');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Dollar"

    // $ANTLR start "Equals"
    public final void mEquals() throws RecognitionException {
        try {
            int _type = Equals;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:234:10: ( '=' )
            // BasicRegexp.g:234:12: '='
            {
                match('=');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Equals"

    // $ANTLR start "LessThan"
    public final void mLessThan() throws RecognitionException {
        try {
            int _type = LessThan;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:235:11: ( '<' )
            // BasicRegexp.g:235:13: '<'
            {
                match('<');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LessThan"

    // $ANTLR start "GreaterThan"
    public final void mGreaterThan() throws RecognitionException {
        try {
            int _type = GreaterThan;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:236:14: ( '>' )
            // BasicRegexp.g:236:16: '>'
            {
                match('>');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GreaterThan"

    // $ANTLR start "ExclamationMark"
    public final void mExclamationMark() throws RecognitionException {
        try {
            int _type = ExclamationMark;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:237:18: ( '!' )
            // BasicRegexp.g:237:20: '!'
            {
                match('!');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ExclamationMark"

    // $ANTLR start "QuestionMark"
    public final void mQuestionMark() throws RecognitionException {
        try {
            int _type = QuestionMark;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:238:15: ( '?' )
            // BasicRegexp.g:238:17: '?'
            {
                match('?');

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "QuestionMark"

    // $ANTLR start "OtherChar"
    public final void mOtherChar() throws RecognitionException {
        try {
            int _type = OtherChar;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // BasicRegexp.g:240:11: (~ ( Escape | And | Or | Hyphen | Caret | Colon | Dollar | SquareBracketStart | SquareBracketEnd | RoundBracketStart | RoundBracketEnd | CurlyBracketStart | CurlyBracketEnd | Equals | LessThan | GreaterThan | ExclamationMark | Comma | Plus | Star | QuestionMark | Dot | Digit | UpperAlpha | LowerAlpha | UnderScore ) )
            // BasicRegexp.g:241:2: ~ ( Escape | And | Or | Hyphen | Caret | Colon | Dollar | SquareBracketStart | SquareBracketEnd | RoundBracketStart | RoundBracketEnd | CurlyBracketStart | CurlyBracketEnd | Equals | LessThan | GreaterThan | ExclamationMark | Comma | Plus | Star | QuestionMark | Dot | Digit | UpperAlpha | LowerAlpha | UnderScore )
            {
                if ((input.LA(1) >= '\u0000' && input.LA(1) <= ' ') || (input.LA(1) >= '\"' && input.LA(1) <= '#') || input.LA(1) == '%' || input.LA(1) == '\'' || input.LA(1) == '/' || input.LA(1) == ';' || input.LA(1) == '@' || input.LA(1) == '`' || (input.LA(1) >= '~' && input.LA(1) <= '\uFFFF')) {
                    input.consume();

                } else {
                    MismatchedSetException mse = new MismatchedSetException(null, input);
                    recover(mse);
                    throw mse;
                }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OtherChar"

    public void mTokens() throws RecognitionException {
        // BasicRegexp.g:1:8: ( Decimal | EscapeSequence | LowerAlpha | UpperAlpha | UnderScore | Plus | Star | Or | Dot | SquareBracketStart | SquareBracketEnd | RoundBracketStart | RoundBracketEnd | CurlyBracketStart | CurlyBracketEnd | Comma | Escape | ShortCharClass | And | Hyphen | Caret | Colon | Dollar | Equals | LessThan | GreaterThan | ExclamationMark | QuestionMark | OtherChar )
        int alt2 = 29;
        alt2 = dfa2.predict(input);
        switch (alt2) {
            case 1:
                // BasicRegexp.g:1:10: Decimal
            {
                mDecimal();

            }
            break;
            case 2:
                // BasicRegexp.g:1:18: EscapeSequence
            {
                mEscapeSequence();

            }
            break;
            case 3:
                // BasicRegexp.g:1:33: LowerAlpha
            {
                mLowerAlpha();

            }
            break;
            case 4:
                // BasicRegexp.g:1:44: UpperAlpha
            {
                mUpperAlpha();

            }
            break;
            case 5:
                // BasicRegexp.g:1:55: UnderScore
            {
                mUnderScore();

            }
            break;
            case 6:
                // BasicRegexp.g:1:66: Plus
            {
                mPlus();

            }
            break;
            case 7:
                // BasicRegexp.g:1:71: Star
            {
                mStar();

            }
            break;
            case 8:
                // BasicRegexp.g:1:76: Or
            {
                mOr();

            }
            break;
            case 9:
                // BasicRegexp.g:1:79: Dot
            {
                mDot();

            }
            break;
            case 10:
                // BasicRegexp.g:1:83: SquareBracketStart
            {
                mSquareBracketStart();

            }
            break;
            case 11:
                // BasicRegexp.g:1:102: SquareBracketEnd
            {
                mSquareBracketEnd();

            }
            break;
            case 12:
                // BasicRegexp.g:1:119: RoundBracketStart
            {
                mRoundBracketStart();

            }
            break;
            case 13:
                // BasicRegexp.g:1:137: RoundBracketEnd
            {
                mRoundBracketEnd();

            }
            break;
            case 14:
                // BasicRegexp.g:1:153: CurlyBracketStart
            {
                mCurlyBracketStart();

            }
            break;
            case 15:
                // BasicRegexp.g:1:171: CurlyBracketEnd
            {
                mCurlyBracketEnd();

            }
            break;
            case 16:
                // BasicRegexp.g:1:187: Comma
            {
                mComma();

            }
            break;
            case 17:
                // BasicRegexp.g:1:193: Escape
            {
                mEscape();

            }
            break;
            case 18:
                // BasicRegexp.g:1:200: ShortCharClass
            {
                mShortCharClass();

            }
            break;
            case 19:
                // BasicRegexp.g:1:215: And
            {
                mAnd();

            }
            break;
            case 20:
                // BasicRegexp.g:1:219: Hyphen
            {
                mHyphen();

            }
            break;
            case 21:
                // BasicRegexp.g:1:226: Caret
            {
                mCaret();

            }
            break;
            case 22:
                // BasicRegexp.g:1:232: Colon
            {
                mColon();

            }
            break;
            case 23:
                // BasicRegexp.g:1:238: Dollar
            {
                mDollar();

            }
            break;
            case 24:
                // BasicRegexp.g:1:245: Equals
            {
                mEquals();

            }
            break;
            case 25:
                // BasicRegexp.g:1:252: LessThan
            {
                mLessThan();

            }
            break;
            case 26:
                // BasicRegexp.g:1:261: GreaterThan
            {
                mGreaterThan();

            }
            break;
            case 27:
                // BasicRegexp.g:1:273: ExclamationMark
            {
                mExclamationMark();

            }
            break;
            case 28:
                // BasicRegexp.g:1:289: QuestionMark
            {
                mQuestionMark();

            }
            break;
            case 29:
                // BasicRegexp.g:1:302: OtherChar
            {
                mOtherChar();

            }
            break;

        }

    }


    protected DFA2 dfa2 = new DFA2(this);
    static final String DFA2_eotS =
            "\2\uffff\1\34\34\uffff";
    static final String DFA2_eofS =
            "\37\uffff";
    static final String DFA2_minS =
            "\1\0\1\uffff\1\0\34\uffff";
    static final String DFA2_maxS =
            "\1\uffff\1\uffff\1\uffff\34\uffff";
    static final String DFA2_acceptS =
            "\1\uffff\1\1\1\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14" +
                    "\1\15\1\16\1\17\1\20\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33" +
                    "\1\34\1\35\1\21\1\2\1\22";
    static final String DFA2_specialS =
            "\1\0\1\uffff\1\1\34\uffff}>";
    static final String[] DFA2_transitionS = {
            "\41\33\1\31\2\33\1\25\1\33\1\21\1\33\1\14\1\15\1\7\1\6\1\20" +
                    "\1\22\1\11\1\33\12\1\1\24\1\33\1\27\1\26\1\30\1\32\1\33\32\4" +
                    "\1\12\1\2\1\13\1\23\1\5\1\33\32\3\1\16\1\10\1\17\uff82\33",
            "",
            "\60\35\12\uffff\7\35\3\uffff\1\36\16\uffff\1\36\3\uffff\1\36" +
                    "\3\uffff\6\35\3\uffff\1\36\16\uffff\1\36\3\uffff\1\36\3\uffff" +
                    "\uff85\35",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i = 0; i < numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }

        public String getDescription() {
            return "1:1: Tokens : ( Decimal | EscapeSequence | LowerAlpha | UpperAlpha | UnderScore | Plus | Star | Or | Dot | SquareBracketStart | SquareBracketEnd | RoundBracketStart | RoundBracketEnd | CurlyBracketStart | CurlyBracketEnd | Comma | Escape | ShortCharClass | And | Hyphen | Caret | Colon | Dollar | Equals | LessThan | GreaterThan | ExclamationMark | QuestionMark | OtherChar );";
        }

        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
            int _s = s;
            switch (s) {
                case 0:
                    int LA2_0 = input.LA(1);

                    s = -1;
                    if (((LA2_0 >= '0' && LA2_0 <= '9'))) {
                        s = 1;
                    } else if ((LA2_0 == '\\')) {
                        s = 2;
                    } else if (((LA2_0 >= 'a' && LA2_0 <= 'z'))) {
                        s = 3;
                    } else if (((LA2_0 >= 'A' && LA2_0 <= 'Z'))) {
                        s = 4;
                    } else if ((LA2_0 == '_')) {
                        s = 5;
                    } else if ((LA2_0 == '+')) {
                        s = 6;
                    } else if ((LA2_0 == '*')) {
                        s = 7;
                    } else if ((LA2_0 == '|')) {
                        s = 8;
                    } else if ((LA2_0 == '.')) {
                        s = 9;
                    } else if ((LA2_0 == '[')) {
                        s = 10;
                    } else if ((LA2_0 == ']')) {
                        s = 11;
                    } else if ((LA2_0 == '(')) {
                        s = 12;
                    } else if ((LA2_0 == ')')) {
                        s = 13;
                    } else if ((LA2_0 == '{')) {
                        s = 14;
                    } else if ((LA2_0 == '}')) {
                        s = 15;
                    } else if ((LA2_0 == ',')) {
                        s = 16;
                    } else if ((LA2_0 == '&')) {
                        s = 17;
                    } else if ((LA2_0 == '-')) {
                        s = 18;
                    } else if ((LA2_0 == '^')) {
                        s = 19;
                    } else if ((LA2_0 == ':')) {
                        s = 20;
                    } else if ((LA2_0 == '$')) {
                        s = 21;
                    } else if ((LA2_0 == '=')) {
                        s = 22;
                    } else if ((LA2_0 == '<')) {
                        s = 23;
                    } else if ((LA2_0 == '>')) {
                        s = 24;
                    } else if ((LA2_0 == '!')) {
                        s = 25;
                    } else if ((LA2_0 == '?')) {
                        s = 26;
                    } else if (((LA2_0 >= '\u0000' && LA2_0 <= ' ') || (LA2_0 >= '\"' && LA2_0 <= '#') || LA2_0 == '%' || LA2_0 == '\'' || LA2_0 == '/' || LA2_0 == ';' || LA2_0 == '@' || LA2_0 == '`' || (LA2_0 >= '~' && LA2_0 <= '\uFFFF'))) {
                        s = 27;
                    }

                    if (s >= 0) return s;
                    break;
                case 1:
                    int LA2_2 = input.LA(1);

                    s = -1;
                    if (((LA2_2 >= '\u0000' && LA2_2 <= '/') || (LA2_2 >= ':' && LA2_2 <= '@') || (LA2_2 >= '[' && LA2_2 <= '`') || (LA2_2 >= '{' && LA2_2 <= '\uFFFF'))) {
                        s = 29;
                    } else if ((LA2_2 == 'D' || LA2_2 == 'S' || LA2_2 == 'W' || LA2_2 == 'd' || LA2_2 == 's' || LA2_2 == 'w')) {
                        s = 30;
                    } else s = 28;

                    if (s >= 0) return s;
                    break;
            }
            NoViableAltException nvae =
                    new NoViableAltException(getDescription(), 2, _s, input);
            error(nvae);
            throw nvae;
        }
    }


}